home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / daolibb / readme.txt < prev    next >
Text File  |  1999-04-16  |  21KB  |  785 lines
  1. DaoLib 2.0 - A complete solution for real world database development.
  2.  
  3.  
  4. 1 - Enhancements in this version - Requirements - Getting started
  5. 2 - Introduction
  6. 3 - Core components
  7. 4 - Intermediate abstractions
  8. 5 - User interface components
  9. 6 - Tutorial and code samples
  10. 7 - Deployment
  11. 8 - Feedback - Support
  12. 9 - Reference
  13. 10 - How to purchase
  14.  
  15.  
  16.  
  17. 1 - Enhancements in this version - Requirements - Getting started
  18.  
  19.     This new version of DaoLib has been rebuilt over the wrapping classes
  20. for DAO provided by the #import directive of Visual C++ 6.0. This means that
  21. it makes extensive use of the built-in support for fundamental COM types and
  22. smart pointers. All this resulted in a more stable and compatible library.
  23.     Unzip the DaoLib file maintaining the directory structure (-d). This
  24. library requires Visual C++ 6.x installed on the development system. The 
  25. evaluation version is fully functional, with a limit of 10 controls per 
  26. dialog and an annoying reminder.
  27.  
  28.  
  29.  
  30. 2 - Introduction
  31.  
  32.     The power of the DAO interface for dealing with databases is an
  33. undeniable fact. It provides a fast and reliable mechanism for data 
  34. management of Access and other ISAM and ODBC databases. Though it was 
  35. engineered targeting scripting languages such as Visual Basic and VBA, it 
  36. provides a dual interface, which allows straightforward C and C++ handling of 
  37. its methods and properties.
  38.     
  39.     The C/C++ developer has several options:
  40.  
  41.     a) Deal with COM interfaces such as DAODatabase, DAORecordset and the 
  42. like using the OS built-in OLE support. This could be tedious and error prone, 
  43. since the developer has to deal with reference counting, object releasing and 
  44. other COM annoying aspects.
  45.  
  46.     b) Go up one level through a C++ proxy. Microsoft provides such a 
  47. proxy-wrapper in its DAO library. This library is rowset-oriented and provides 
  48. a valuable variable binding mechanism, but it is not the best solution for 
  49. handling record-oriented applications.
  50.  
  51.     c) Use some framework which integrates the database specifics with a 
  52. user interface management. MFC-DAO is an example of this approach. The problem 
  53. here is that the integration is best suited for a Doc/View architecture, and 
  54. it adds some complexity when dealing with dialog intensive applications.
  55.  
  56.     DaoLib was built with this three-level separation of concerns. It deals 
  57. with all the COM burden, such as exception handling, reference counting and 
  58. object lifespan. It provides a wrapper level you can access directly, and it 
  59. integrates to MFC with little overhead.
  60.  
  61.  
  62.  
  63. 3 - Core components
  64.  
  65.     The classes at this level are wrapped around DAO components. In 
  66. addition, you can use helper classes such as _bstr_t, _variant_t and 
  67. Currency, which encapsulate the BSTR, VARIANT and CURRENCY semantics, allowing 
  68. a very robust parameter handling. _com_error manages error handling, converting 
  69. COM error objects into C++ exceptions.
  70.  
  71.     The instantiation of Dao objects was simplified through smart 
  72. constructors, many of which take no arguments or a single string object. The 
  73. enumerator semantics is replaced by a simpler indexing mechanism. The use of 
  74. the 'property' Microsoft extension allows a 'VB-like' syntax in many cases: 
  75. using Variant indexes, you can refer to a specific field as:
  76.     FieldValue[0] or as: FieldValue["CustomerID"]
  77. In addition, the same property (if marked read/write) can be a left or right 
  78. value.
  79.  
  80.     These are the core components and their mapping to DAO components:
  81.  
  82.     _FieldPtr        DAOField
  83.     DaoRecordset        DAORecordset
  84.     DatabasePtr        DAODatabase
  85.     WorkspacePtr        DAOWorkspace
  86.     _DBEnginePtr        DAODBEngine
  87.     ParameterPtr        DAOParameter
  88.     _QueryDefPtr        DAOQueryDef
  89.     _TableDefPtr        DAOTableDef
  90.     _IndexPtr        DAOIndex
  91.     _UserPtr        DAOUser
  92.     _GroupPtr        DAOGroup
  93.     _RelationPtr        DAORelation
  94.     ConnectionPtr        DAOConnection
  95.     PropertyPtr        DAOProperty
  96.  
  97.     These are the helper classes and their COM counterparts:
  98.  
  99.     _bstr_t            BSTR
  100.     _variant_t        VARIANT
  101.     Currency        CURRENCY
  102.  
  103.     This has no counterparts:
  104.     
  105.     _com_error        Error handling through exception throwing.
  106.  
  107.  
  108.  
  109. 4 - Intermediate abstractions
  110.  
  111.     In order to connect database objects with user interface elements 
  112. such as controls, windows or dialogs, a couple of intermediate level 
  113. abstract classes must be added to the hierarchy. These are DaoWindow and 
  114. DaoControl. A windowing user interface element must inherit from DaoWindow 
  115. and a control element from DaoControl to have complete control of its 
  116. underlying database objects. They interact tightly with MFC transfer 
  117. mechanisms. 
  118.  
  119.  
  120.  
  121. 5 - User interface components
  122.  
  123.     DaoLib comes with several user interface components, but its open 
  124. architecture allows you to add your own custom components. The basic 
  125. components are:
  126.  
  127.     Windowing components:
  128.         
  129.         DaoDialog
  130.         DaoPropSheet
  131.         DaoPropPage
  132.  
  133.     Control components:
  134.         
  135.         DaoEdit
  136.         DaoCheck
  137.         DaoRadio
  138.         DaoGroup
  139.         DaoCombo
  140.         DaoListCtrl
  141.  
  142.     Complete components:
  143.         
  144.         ListDialog
  145.         
  146.     The windowing components are intended to be used as base classes of
  147. your dialog objects. You can create regular dialogs or property pages using 
  148. the ClassWizard and then replace the base class in the declaration and add
  149. the constructor arguments. ClassWizard will still recognize your class and 
  150. it even will use DaoDialog or DaoPropPage when adding base class references.
  151.  
  152.     The control classes can be used directly. Once again, you create 
  153. control objects with ClassWizard and then replace their declaration (you can 
  154. use the 'Replace' command if you have many controls). You can manage some 
  155. attributes of the controls at declaration time, such as enabling or writing 
  156. denial.
  157.  
  158.     DaoLib includes a powerful dialog-based component called ListDialog.
  159. It manages the display of Recordset objects through a list control, naming 
  160. each header column upon the field's name and formatting the data according 
  161. to each data type. In addition, it provides complete printing support for the
  162. list control's contents, sorting through column header clicking, keyboard 
  163. support (Insert for adding records, Delete for deleting, Enter for viewing),
  164. and a mouse driven context menu with those same functions.
  165.  
  166.  
  167.  
  168. 6 - Tutorial and code samples
  169.  
  170.     The use of the library does not require any special skill. If you use
  171. Visual C++ and feel comfortable with the ClassWizard, you can produce DaoLib 
  172. code immediately. The steps to follow are:
  173.  
  174.     1 - You can create a project without database support, or use an 
  175. existing project. Add DaoLib2.lib to the libraries in the project settings 
  176. (Link page). Map the include path accordingly (C/C++ - Preprocessor).
  177.  
  178.  
  179.     2 - In the declaration of your App class, add the core #include 
  180.  
  181. #include "resource.h"       // main symbols
  182.  
  183. becomes:
  184.  
  185. #include "resource.h"       // main symbols
  186. #include "bordao.h"
  187.  
  188.  
  189.     3 - In InitInstance, add the Database initialization:
  190.  
  191.     CMainFrame* pFrame = new CMainFrame;
  192.     m_pMainWnd = pFrame;
  193.  
  194. becomes:
  195.  
  196.     try {
  197.           OpenDatabase("mydata.mdb");    //full path here, unless same
  198.                         //directory as .EXE
  199.     }
  200.     catch(_com_error& e) {
  201.            Show(e);
  202.         return FALSE;
  203.     }
  204.  
  205.     CMainFrame* pFrame = new CMainFrame;
  206.     m_pMainWnd = pFrame;
  207.  
  208.  
  209.     4 - Create the appropiate dialog resource. Assign each control an ID
  210. that resembles the name of the field with which it is associated. You can 
  211. optionally add a Modify button (ID = 302). It must be the first in the 
  212. control creation order. You may also add a Enter button (ID = 301). It must 
  213. be non-visible, non-tabstop and marked as default button (unmark the OK 
  214. button).
  215.  
  216.  
  217.     5 - Open the ClassWizard and create the CDialog as usual. For each 
  218. control, assign a member variable (Category: Control) of the required type. 
  219. If you want to use the macros provided with DaoLib (recommended), give each 
  220. control the exact name of the corresponding field, prefixed with 'm_' (for a 
  221. field named CustomerID it should be m_CustomerID).
  222.     
  223.  
  224.     6 - Close the ClassWizard and go to the dialog's class declaration 
  225. (*.h file). Replace CDialog with CDaoDialog in the inheritance tag and add 
  226. two parameters to the constructor before the existing one:
  227.  
  228. class